home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / acpi / acpi_bus.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  11.3 KB  |  409 lines
  1. /*
  2.  *  acpi_bus.h - ACPI Bus Driver ($Revision: 22 $)
  3.  *
  4.  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
  5.  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
  6.  *
  7.  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  8.  *
  9.  *  This program is free software; you can redistribute it and/or modify
  10.  *  it under the terms of the GNU General Public License as published by
  11.  *  the Free Software Foundation; either version 2 of the License, or (at
  12.  *  your option) any later version.
  13.  *
  14.  *  This program is distributed in the hope that it will be useful, but
  15.  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17.  *  General Public License for more details.
  18.  *
  19.  *  You should have received a copy of the GNU General Public License along
  20.  *  with this program; if not, write to the Free Software Foundation, Inc.,
  21.  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  22.  *
  23.  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  24.  */
  25.  
  26. #ifndef __ACPI_BUS_H__
  27. #define __ACPI_BUS_H__
  28.  
  29. #include <linux/device.h>
  30.  
  31. #include <acpi/acpi.h>
  32.  
  33. #define PREFIX            "ACPI: "
  34.  
  35. /* TBD: Make dynamic */
  36. #define ACPI_MAX_HANDLES    10
  37. struct acpi_handle_list {
  38.     u32 count;
  39.     acpi_handle handles[ACPI_MAX_HANDLES];
  40. };
  41.  
  42. /* acpi_utils.h */
  43. acpi_status
  44. acpi_extract_package(union acpi_object *package,
  45.              struct acpi_buffer *format, struct acpi_buffer *buffer);
  46. acpi_status
  47. acpi_evaluate_integer(acpi_handle handle,
  48.               acpi_string pathname,
  49.               struct acpi_object_list *arguments, unsigned long long *data);
  50. acpi_status
  51. acpi_evaluate_reference(acpi_handle handle,
  52.             acpi_string pathname,
  53.             struct acpi_object_list *arguments,
  54.             struct acpi_handle_list *list);
  55.  
  56. #ifdef CONFIG_ACPI
  57.  
  58. #include <linux/proc_fs.h>
  59.  
  60. #define ACPI_BUS_FILE_ROOT    "acpi"
  61. extern struct proc_dir_entry *acpi_root_dir;
  62.  
  63. enum acpi_bus_removal_type {
  64.     ACPI_BUS_REMOVAL_NORMAL = 0,
  65.     ACPI_BUS_REMOVAL_EJECT,
  66.     ACPI_BUS_REMOVAL_SUPRISE,
  67.     ACPI_BUS_REMOVAL_TYPE_COUNT
  68. };
  69.  
  70. enum acpi_bus_device_type {
  71.     ACPI_BUS_TYPE_DEVICE = 0,
  72.     ACPI_BUS_TYPE_POWER,
  73.     ACPI_BUS_TYPE_PROCESSOR,
  74.     ACPI_BUS_TYPE_THERMAL,
  75.     ACPI_BUS_TYPE_SYSTEM,
  76.     ACPI_BUS_TYPE_POWER_BUTTON,
  77.     ACPI_BUS_TYPE_SLEEP_BUTTON,
  78.     ACPI_BUS_DEVICE_TYPE_COUNT
  79. };
  80.  
  81. struct acpi_driver;
  82. struct acpi_device;
  83.  
  84. /*
  85.  * ACPI Driver
  86.  * -----------
  87.  */
  88.  
  89. typedef int (*acpi_op_add) (struct acpi_device * device);
  90. typedef int (*acpi_op_remove) (struct acpi_device * device, int type);
  91. typedef int (*acpi_op_lock) (struct acpi_device * device, int type);
  92. typedef int (*acpi_op_start) (struct acpi_device * device);
  93. typedef int (*acpi_op_stop) (struct acpi_device * device, int type);
  94. typedef int (*acpi_op_suspend) (struct acpi_device * device,
  95.                 pm_message_t state);
  96. typedef int (*acpi_op_resume) (struct acpi_device * device);
  97. typedef int (*acpi_op_scan) (struct acpi_device * device);
  98. typedef int (*acpi_op_bind) (struct acpi_device * device);
  99. typedef int (*acpi_op_unbind) (struct acpi_device * device);
  100. typedef int (*acpi_op_shutdown) (struct acpi_device * device);
  101.  
  102. struct acpi_bus_ops {
  103.     u32 acpi_op_add:1;
  104.     u32 acpi_op_remove:1;
  105.     u32 acpi_op_lock:1;
  106.     u32 acpi_op_start:1;
  107.     u32 acpi_op_stop:1;
  108.     u32 acpi_op_suspend:1;
  109.     u32 acpi_op_resume:1;
  110.     u32 acpi_op_scan:1;
  111.     u32 acpi_op_bind:1;
  112.     u32 acpi_op_unbind:1;
  113.     u32 acpi_op_shutdown:1;
  114.     u32 reserved:21;
  115. };
  116.  
  117. struct acpi_device_ops {
  118.     acpi_op_add add;
  119.     acpi_op_remove remove;
  120.     acpi_op_lock lock;
  121.     acpi_op_start start;
  122.     acpi_op_stop stop;
  123.     acpi_op_suspend suspend;
  124.     acpi_op_resume resume;
  125.     acpi_op_scan scan;
  126.     acpi_op_bind bind;
  127.     acpi_op_unbind unbind;
  128.     acpi_op_shutdown shutdown;
  129. };
  130.  
  131. struct acpi_driver {
  132.     char name[80];
  133.     char class[80];
  134.     const struct acpi_device_id *ids; /* Supported Hardware IDs */
  135.     struct acpi_device_ops ops;
  136.     struct device_driver drv;
  137.     struct module *owner;
  138. };
  139.  
  140. /*
  141.  * ACPI Device
  142.  * -----------
  143.  */
  144.  
  145. /* Status (_STA) */
  146.  
  147. struct acpi_device_status {
  148.     u32 present:1;
  149.     u32 enabled:1;
  150.     u32 show_in_ui:1;
  151.     u32 functional:1;
  152.     u32 battery_present:1;
  153.     u32 reserved:27;
  154. };
  155.  
  156. /* Flags */
  157.  
  158. struct acpi_device_flags {
  159.     u32 dynamic_status:1;
  160.     u32 hardware_id:1;
  161.     u32 compatible_ids:1;
  162.     u32 bus_address:1;
  163.     u32 unique_id:1;
  164.     u32 removable:1;
  165.     u32 ejectable:1;
  166.     u32 lockable:1;
  167.     u32 suprise_removal_ok:1;
  168.     u32 power_manageable:1;
  169.     u32 performance_manageable:1;
  170.     u32 wake_capable:1;    /* Wakeup(_PRW) supported? */
  171.     u32 force_power_state:1;
  172.     u32 reserved:19;
  173. };
  174.  
  175. /* File System */
  176.  
  177. struct acpi_device_dir {
  178.     struct proc_dir_entry *entry;
  179. };
  180.  
  181. #define acpi_device_dir(d)    ((d)->dir.entry)
  182.  
  183. /* Plug and Play */
  184.  
  185. typedef char acpi_bus_id[5];
  186. typedef unsigned long acpi_bus_address;
  187. typedef char acpi_hardware_id[15];
  188. typedef char acpi_unique_id[9];
  189. typedef char acpi_device_name[40];
  190. typedef char acpi_device_class[20];
  191.  
  192. struct acpi_device_pnp {
  193.     acpi_bus_id bus_id;    /* Object name */
  194.     acpi_bus_address bus_address;    /* _ADR */
  195.     acpi_hardware_id hardware_id;    /* _HID */
  196.     struct acpi_compatible_id_list *cid_list;    /* _CIDs */
  197.     acpi_unique_id unique_id;    /* _UID */
  198.     acpi_device_name device_name;    /* Driver-determined */
  199.     acpi_device_class device_class;    /*        "          */
  200. };
  201.  
  202. #define acpi_device_bid(d)    ((d)->pnp.bus_id)
  203. #define acpi_device_adr(d)    ((d)->pnp.bus_address)
  204. #define acpi_device_hid(d)    ((d)->pnp.hardware_id)
  205. #define acpi_device_uid(d)    ((d)->pnp.unique_id)
  206. #define acpi_device_name(d)    ((d)->pnp.device_name)
  207. #define acpi_device_class(d)    ((d)->pnp.device_class)
  208.  
  209. /* Power Management */
  210.  
  211. struct acpi_device_power_flags {
  212.     u32 explicit_get:1;    /* _PSC present? */
  213.     u32 power_resources:1;    /* Power resources */
  214.     u32 inrush_current:1;    /* Serialize Dx->D0 */
  215.     u32 power_removed:1;    /* Optimize Dx->D0 */
  216.     u32 reserved:28;
  217. };
  218.  
  219. struct acpi_device_power_state {
  220.     struct {
  221.         u8 valid:1;
  222.         u8 explicit_set:1;    /* _PSx present? */
  223.         u8 reserved:6;
  224.     } flags;
  225.     int power;        /* % Power (compared to D0) */
  226.     int latency;        /* Dx->D0 time (microseconds) */
  227.     struct acpi_handle_list resources;    /* Power resources referenced */
  228. };
  229.  
  230. struct acpi_device_power {
  231.     int state;        /* Current state */
  232.     struct acpi_device_power_flags flags;
  233.     struct acpi_device_power_state states[4];    /* Power states (D0-D3) */
  234. };
  235.  
  236. /* Performance Management */
  237.  
  238. struct acpi_device_perf_flags {
  239.     u8 reserved:8;
  240. };
  241.  
  242. struct acpi_device_perf_state {
  243.     struct {
  244.         u8 valid:1;
  245.         u8 reserved:7;
  246.     } flags;
  247.     u8 power;        /* % Power (compared to P0) */
  248.     u8 performance;        /* % Performance (    "   ) */
  249.     int latency;        /* Px->P0 time (microseconds) */
  250. };
  251.  
  252. struct acpi_device_perf {
  253.     int state;
  254.     struct acpi_device_perf_flags flags;
  255.     int state_count;
  256.     struct acpi_device_perf_state *states;
  257. };
  258.  
  259. /* Wakeup Management */
  260. struct acpi_device_wakeup_flags {
  261.     u8 valid:1;        /* Can successfully enable wakeup? */
  262.     u8 prepared:1;        /* Has the wake-up capability been enabled? */
  263.     u8 run_wake:1;        /* Run-Wake GPE devices */
  264. };
  265.  
  266. struct acpi_device_wakeup_state {
  267.     u8 enabled:1;
  268. };
  269.  
  270. struct acpi_device_wakeup {
  271.     acpi_handle gpe_device;
  272.     acpi_integer gpe_number;
  273.     acpi_integer sleep_state;
  274.     struct acpi_handle_list resources;
  275.     struct acpi_device_wakeup_state state;
  276.     struct acpi_device_wakeup_flags flags;
  277. };
  278.  
  279. /* Device */
  280.  
  281. struct acpi_device {
  282.     acpi_handle handle;
  283.     struct acpi_device *parent;
  284.     struct list_head children;
  285.     struct list_head node;
  286.     struct list_head wakeup_list;
  287.     struct list_head g_list;
  288.     struct acpi_device_status status;
  289.     struct acpi_device_flags flags;
  290.     struct acpi_device_pnp pnp;
  291.     struct acpi_device_power power;
  292.     struct acpi_device_wakeup wakeup;
  293.     struct acpi_device_perf performance;
  294.     struct acpi_device_dir dir;
  295.     struct acpi_device_ops ops;
  296.     struct acpi_driver *driver;
  297.     void *driver_data;
  298.     struct device dev;
  299.     struct acpi_bus_ops bus_ops;    /* workaround for different code path for hotplug */
  300.     enum acpi_bus_removal_type removal_type;    /* indicate for different removal type */
  301. };
  302.  
  303. static inline void *acpi_driver_data(struct acpi_device *d)
  304. {
  305.     return d->driver_data;
  306. }
  307.  
  308. #define to_acpi_device(d)    container_of(d, struct acpi_device, dev)
  309. #define to_acpi_driver(d)    container_of(d, struct acpi_driver, drv)
  310.  
  311. /* acpi_device.dev.bus == &acpi_bus_type */
  312. extern struct bus_type acpi_bus_type;
  313.  
  314. /*
  315.  * Events
  316.  * ------
  317.  */
  318.  
  319. struct acpi_bus_event {
  320.     struct list_head node;
  321.     acpi_device_class device_class;
  322.     acpi_bus_id bus_id;
  323.     u32 type;
  324.     u32 data;
  325. };
  326.  
  327. extern struct kobject *acpi_kobj;
  328. extern int acpi_bus_generate_netlink_event(const char*, const char*, u8, int);
  329. void acpi_bus_private_data_handler(acpi_handle, u32, void *);
  330. int acpi_bus_get_private_data(acpi_handle, void **);
  331. extern int acpi_notifier_call_chain(struct acpi_device *, u32, u32);
  332. extern int register_acpi_notifier(struct notifier_block *);
  333. extern int unregister_acpi_notifier(struct notifier_block *);
  334.  
  335. extern int register_acpi_bus_notifier(struct notifier_block *nb);
  336. extern void unregister_acpi_bus_notifier(struct notifier_block *nb);
  337. /*
  338.  * External Functions
  339.  */
  340.  
  341. int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device);
  342. void acpi_bus_data_handler(acpi_handle handle, u32 function, void *context);
  343. int acpi_bus_get_status(struct acpi_device *device);
  344. int acpi_bus_get_power(acpi_handle handle, int *state);
  345. int acpi_bus_set_power(acpi_handle handle, int state);
  346. bool acpi_bus_power_manageable(acpi_handle handle);
  347. bool acpi_bus_can_wakeup(acpi_handle handle);
  348. #ifdef CONFIG_ACPI_PROC_EVENT
  349. int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data);
  350. int acpi_bus_generate_proc_event4(const char *class, const char *bid, u8 type, int data);
  351. int acpi_bus_receive_event(struct acpi_bus_event *event);
  352. #else
  353. static inline int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data)
  354.     { return 0; }
  355. #endif
  356. int acpi_bus_register_driver(struct acpi_driver *driver);
  357. void acpi_bus_unregister_driver(struct acpi_driver *driver);
  358. int acpi_bus_add(struct acpi_device **child, struct acpi_device *parent,
  359.          acpi_handle handle, int type);
  360. int acpi_bus_trim(struct acpi_device *start, int rmdevice);
  361. int acpi_bus_start(struct acpi_device *device);
  362. acpi_status acpi_bus_get_ejd(acpi_handle handle, acpi_handle * ejd);
  363. int acpi_match_device_ids(struct acpi_device *device,
  364.               const struct acpi_device_id *ids);
  365. int acpi_create_dir(struct acpi_device *);
  366. void acpi_remove_dir(struct acpi_device *);
  367.  
  368. /*
  369.  * Bind physical devices with ACPI devices
  370.  */
  371. #include <linux/device.h>
  372. struct acpi_bus_type {
  373.     struct list_head list;
  374.     struct bus_type *bus;
  375.     /* For general devices under the bus */
  376.     int (*find_device) (struct device *, acpi_handle *);
  377.     /* For bridges, such as PCI root bridge, IDE controller */
  378.     int (*find_bridge) (struct device *, acpi_handle *);
  379. };
  380. int register_acpi_bus_type(struct acpi_bus_type *);
  381. int unregister_acpi_bus_type(struct acpi_bus_type *);
  382. struct device *acpi_get_physical_device(acpi_handle);
  383. struct device *acpi_get_physical_pci_device(acpi_handle);
  384.  
  385. /* helper */
  386. acpi_handle acpi_get_child(acpi_handle, acpi_integer);
  387. acpi_handle acpi_get_pci_rootbridge_handle(unsigned int, unsigned int);
  388. #define DEVICE_ACPI_HANDLE(dev) ((acpi_handle)((dev)->archdata.acpi_handle))
  389.  
  390. #ifdef CONFIG_PM_SLEEP
  391. int acpi_pm_device_sleep_state(struct device *, int *);
  392. int acpi_pm_device_sleep_wake(struct device *, bool);
  393. #else /* !CONFIG_PM_SLEEP */
  394. static inline int acpi_pm_device_sleep_state(struct device *d, int *p)
  395. {
  396.     if (p)
  397.         *p = ACPI_STATE_D0;
  398.     return ACPI_STATE_D3;
  399. }
  400. static inline int acpi_pm_device_sleep_wake(struct device *dev, bool enable)
  401. {
  402.     return -ENODEV;
  403. }
  404. #endif /* !CONFIG_PM_SLEEP */
  405.  
  406. #endif                /* CONFIG_ACPI */
  407.  
  408. #endif /*__ACPI_BUS_H__*/
  409.